/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package Clases;

/**
 *
 * @author lis
 */
public class listaSimple {

    Nodo primero, ultimo;

    //Metodo Constructor sin parametros
    public listaSimple()
    {
        primero=ultimo=null;
    }

    /*
      *Recuperacion de valores
      *Metodos get
      */
    public Nodo Primero()
    {
        return primero;
    }

    public Nodo Ultimo()
    {
        return ultimo;
    }

    //Metodo que booleano para confirmar si la lista es vacia o no
    public boolean esVacia()
    {
        if(primero==null)
            return true;
        else
            return false;
    }

    //Metodo para buscar un dato en la lista
    //retorna el nodo que contiene el dato
    public Nodo buscar(int d)
    {
        Nodo x = Primero();

        while ( (x != null) & (x.Ret_Dato() != d) )
        {
            x = x.Ret_Sig();
        }

        return x;
    }

    //Metodo para buscar el nodo anterior
    //del nodo que se ingresa como parametro
    public Nodo anterior(Nodo x)
    {
        Nodo ant=Primero();
        while (ant.Ret_Sig() != x)
        {
            ant = ant.Ret_Sig();
        }

        return ant;
    }

    //Metodo de insercion al principio de la lista
    public void insertarPrincipio(int d)
    {
        Nodo nuevo = new Nodo(d);
        if(esVacia() == true)
            {primero=ultimo=nuevo;}
        else
            {
                nuevo.Asig_Sig(Primero());
                primero=nuevo;
            }
    }

    //Metodo de insercion al final de la lista
    public void insertarUltimo(int d)
    {
        Nodo nuevo = new Nodo(d);
        if(esVacia() == true)
            {primero=ultimo=nuevo;}
        else
            {
                Ultimo().Asig_Sig(nuevo);
                ultimo=nuevo;
            }
    }

    //Metodo para mostrar los datos de la lista
    //en el orden en el cual estan en la lista
    public void mostrar()
    {
        Nodo z;
        z=Primero();
        while(z != null)
        {
            System.out.println(+z.Ret_Dato());
            z = z.Ret_Sig();
        }
    }

    //Metodo de insercion ordenada a la lista
    public void insertarOrdenada(int d)
    {
        try
        {
        Nodo z,ant,nuevo;
        if(esVacia() == true)
            {insertarPrincipio(d);}
        else
            {
                z = Primero();
                while(z.Ret_Dato() < d & z != null)
                {z = z.Ret_Sig();}

                if(z != null)
                {
                    if(z==Primero())
                        {insertarPrincipio(d);}
                    else
                        {
                            nuevo = new Nodo(d);
                            ant = anterior(z);
                            ant.Asig_Sig(nuevo);
                            nuevo.Asig_Sig(z);
                        }
                }
            }
        }
        catch (Exception e)
        {
            insertarUltimo(d);
        }
    }

    //Metodo para eliminar el primer nodo que se encuentre en la lista
    //cuyo dato coincida con el dato ingresado
    public void eliminarPrimeraCoincidencia(int d)
    {
        try
        {
            Nodo ant,z;
            if(esVacia() == true)
                {
                    System.out.println("Lista Vacia");
                    return;
                }

            z = buscar(d);

            if(z != null)
            {
                if(z==Primero())
                    {
                        primero = Primero().Ret_Sig();
                        if(primero==null)
                            ultimo=null;
                    }
                else
                    {
                        ant = anterior(z);
                        ant.Asig_Sig(z.Ret_Sig());
                        if(z==ultimo)
                            ultimo=ant;
                    }
            }
        }
        catch(Exception e)
        {
            System.out.println("No existe "+d+" en lista");
            return;
        }
    }

    //Metodo para eliminar todos los nodos que se encuentren en la lista
    //cuyos datos coincidan con el dato ingresado
    public void eliminarTodasCoincidencias(int d)
    {
        int coincidencias=0;
        try
        {
            Nodo ant,z;
            if(esVacia() == true)
                {
                    System.out.println("Lista Vacia");
                    return;
                }

            z = buscar(d);

             while (z != null)
                {
                    if(z==Primero())
                        {
                            primero = Primero().Ret_Sig();
                            if(primero==null)
                                ultimo=null;
                        }
                    else
                        {
                            ant = anterior(z);
                            ant.Asig_Sig(z.Ret_Sig());
                            if(z==ultimo)
                                ultimo=ant;
                        }
                    z = buscar(d);
                    coincidencias++;
                }


        }
        catch(Exception e)
        {
            if(coincidencias==0)
            {
                System.out.println("No existe "+d+" en lista");
            }
        }
    }

    //Metodo para borrar la lista
    public void borrarLista()
    {
        primero=ultimo=null;
    }

}
